//-----------------------------------------------------------
//Author : H4304 
//Projet : ciai 4IF
//Thread : conditionnement
//Description : Place des pieces dans un carton 
//-----------------------------------------------------------

//--------INCLUDE 
#include "conditionnement.h"
#include "../Outils/config.h"
#include "../Outils/simulation.h"
#include <stdio.h>
#include <stdlib.h>
#include <sys/time.h>
#include <time.h>
#include <mqueue.h>
#include <string.h>
#include <pthread.h>
//-------

//-----Constantes 
#define ZERO 0
#define PRODUIT_A 'A'
#define PRODUIT_B 'B'
#define FAUX 0
#define VRAI 1
//-------

//-----Statiques

// Carton A sur la Palette 
static unsigned int nb_cartonsA_sur_palette=0;

// Carton B sur la Palette
static unsigned int nb_cartonsB_sur_palette=0; 

// Nombre Palette A
static unsigned int nb_des_paletteA=0;

// Nombre Palette B 
static unsigned int nb_des_paletteB=0; 

// Numero carton A
static unsigned int numero_cartonA =0;

// Numero carton B
static unsigned int numero_cartonB =0; 

// Piece dans le carton A  
static unsigned int nb_piece_cartonA = 0; 

// Piece defectueuse pour un carton A
static unsigned int nb_piece_defectueuseA = 0;

// Piece dans le carton B
static unsigned int nb_piece_cartonB = 0; 

// Piece defectueuse pour un carton B 
static unsigned int nb_piece_defectueuseB = 0;

// Numero du Lot
static unsigned int numero_lot = 0;

// Nombre piece produit A
static int taille_CartonA = -1; 

// Nombre piece produit B
static int taille_CartonB = -1;  

// Taille de palette A
static int taille_PaletteA = -1; 

// Taille de palette B
static int taille_PaletteB = -1; 

// Nombre de palette A
static int nb_PaletteA = -1; 

// Nombre de palette B
static int nb_PaletteB = -1; 

//-----------------

void *Conditionnement()
{	
	// Declaration variables 
	unsigned int etat_clapet;
	unsigned int presence_carton;
	unsigned int seuil_piece_defectueuse; 

	//Messages
	MSG_demarrage msg_demarrage;  
	MSG_versArchivage msg_versArchivage; 
	MSG_carton msg_carton;
	MSG_versErreur msg_versErreur;
	MSG_retErreur msg_retErreur;
	MSG_dimension msg_dimension;  

	//Boites aux lettres 
	mqd_t lecture_conditionnement;
	mqd_t conditionnement_dimension; 
	mqd_t conditionnement_impression;
	mqd_t conditionnement_archivage;
	mqd_t conditionnement_erreur;
	mqd_t erreur_conditionnement;
	
	// Valeur retournee par les boites aux lettres en lecture 
	int bytes_read; 

	//----------- Phase d initialisation

	// Ouverture des boites aux lettres 
	lecture_conditionnement =  mq_open(BAL_demarrage,O_RDONLY); // En Lecture seulement
	conditionnement_dimension =  mq_open(BAL_DIMENSION,O_RDONLY); // En Lecture seulement 
	conditionnement_impression =  mq_open(BAL_versImpression,O_WRONLY); // En Ecriture seulement 
	conditionnement_archivage =  mq_open(BAL_versArchivage,O_WRONLY); // En Ecriture seulement
	conditionnement_erreur =  mq_open(BAL_versErreur,O_WRONLY); // En Ecriture seulement 
	erreur_conditionnement = mq_open(BAL_retErreur,O_RDONLY); // En Lecture seulement 	
	
	//----- Fin Phase d initialisation
	
	//------------ Phase moteur 
	for(;;)
	{
		// Attente d un message de Lecture
		bytes_read = mq_receive(lecture_conditionnement,(char*)&msg_demarrage,sizeof(MSG_demarrage),NULL);

		printf("[ConditionnementThread] Lancement Production\n"); 
		if (bytes_read == -1)
  		{
   			perror("[ConditionnementThread] Echec lors de la reception: ");
   			return 0;
  		}
  		else
		{
			// Ouverture Clapet
			OuvertureClapet(); 
			// Etat du clapet 
			etat_clapet = EtatClapet(); 
			if (etat_clapet == CLAPET_F)
			{
				// Attente d un message de Erreur
				bytes_read = mq_receive(erreur_conditionnement,(char*)&msg_retErreur,sizeof(MSG_retErreur),NULL);
				if (bytes_read == -1)
  				{
   					perror("[ConditionnementThread] Echec lors de la reception ");
  				}
				if (msg_retErreur.reponse == FIN_APPLI)
				{
					// Creation du message a envoyer a Impression
					msg_carton.type = FIN_APPLI;   
					msg_carton.numCarton = ZERO; 
					msg_carton.numLot = ZERO;
					msg_carton.typeProduit = ZERO;

					// Envoi de FIN APPLICATION a Impression 
					if (0 != mq_send (conditionnement_impression,(const char*)&msg_carton,sizeof(MSG_carton),PRIO_MSG_L))
					{
						perror ("[ConditionnementThread] Echec envoi FIN_APPLI a Impression ");
					}

					// Envoi de FIN APPLICATION a Impression 
					if (0 != mq_send (conditionnement_impression,(const char*)&msg_carton,sizeof(MSG_carton),PRIO_MSG_L))
					{
						perror ("[ConditionnementThread] Echec envoi FIN_APPLI a Impression ");
					}
					// Fermeture Boite aux lettres 
					mq_close (erreur_conditionnement);
					mq_close (conditionnement_dimension); 
					mq_close (conditionnement_erreur);
					mq_close (conditionnement_archivage);
					mq_close (conditionnement_impression);
					mq_close (lecture_conditionnement);
					// Le Thread Conditionnement se suicide
					pthread_exit(0); 
				}
			}
			
			if (etat_clapet == CLAPET_O)
			{ 
				// Lecture des infos dans la memoire partagee
				pthread_mutex_lock(MutexSHMOF); 
				numero_lot = OrdreFabrication->numLot;  
				taille_CartonA = OrdreFabrication->tailleCartonA;
				taille_PaletteA = OrdreFabrication->taillePaletteA; 
				nb_PaletteA = OrdreFabrication->nbPaletteA;
				taille_CartonB = OrdreFabrication->tailleCartonB;
				taille_PaletteB = OrdreFabrication->taillePaletteB; 
				nb_PaletteB = OrdreFabrication->nbPaletteB;
				pthread_mutex_unlock(MutexSHMOF); 
				//--------DEBUT PRODUIT A
				if ( (taille_CartonA*taille_PaletteA*nb_PaletteA) != 0)
				{
					// Remplissage de toutes les palettes A
					do{
						nb_des_paletteA++; 					
						printf("---> NUMERO PALETTE A : %d \n",nb_des_paletteA); 					
						nb_cartonsA_sur_palette = 0; 
						// Remplissage d une palette A
						do
						{
							
							// Seuil de piece defectueuse fixe
							seuil_piece_defectueuse = taille_CartonA/2; 

							presence_carton = PresenceCarton();
							if (presence_carton == CARTON_OK)
							{
								nb_cartonsA_sur_palette++; 
								numero_cartonA++;
								printf("---> NUMERO CARTON A : %d\n",numero_cartonA);

								nb_piece_cartonA = 0;
								nb_piece_defectueuseA = 0;
								// Remplissage d un carton A						
								do
								{
									struct timespec abs_timeout;
									abs_timeout.tv_sec = time(NULL) + 6;
									abs_timeout.tv_nsec = 0;  
									
									// Attente Message dimensionnement 
									bytes_read = mq_timedreceive(conditionnement_dimension,(char *)&msg_dimension,
							  sizeof(MSG_dimension),NULL,&abs_timeout);
									
									if (bytes_read == -1)
									{
										perror("[ConditionnementThread] Echec reception dimension piece \n ");
										// Creation Message pour Erreur
										msg_versErreur.source = T_CONDITIONNEMENT; 
										msg_versErreur.message = ABS_PIECE; 
										msg_versErreur.heure = time(NULL);
										msg_versErreur.numLot = numero_lot; 
										msg_versErreur.cartonEnCours = numero_cartonA;	
										 							
										if(0 != mq_send (conditionnement_erreur,(char*)&msg_versErreur,sizeof(MSG_versErreur),PRIO_MSG_L))
										{
											perror("[ConditionnementThread] Echec envoi message a Erreur "); 
										}
											
										// Attente d un message de Erreur
										bytes_read = mq_receive(erreur_conditionnement,(char*)&msg_retErreur,sizeof(MSG_retErreur),NULL);
										if (bytes_read == -1)
										{
											perror("[ConditionnementThread] Echec lors de la reception ");
										}
										
										if (msg_retErreur.reponse == FIN_APPLI)
										{
											// Creation du message a envoyer a Impression
											msg_carton.type = FIN_APPLI;   
											msg_carton.numCarton = ZERO; 
											msg_carton.numLot = ZERO;
											msg_carton.typeProduit = ZERO;
											 
											// Envoi de FIN APPLICATION a Impression 
											if (0 != mq_send (conditionnement_impression,(const char*)&msg_carton,sizeof(MSG_carton),PRIO_MSG_L))
											{
												perror ("[ConditionnementThread] Echec envoi FIN_APPLI a Impression ");
											}

											// Envoi de FIN APPLICATION a Impression 
											if (0 != mq_send (conditionnement_impression,(const char*)&msg_carton,sizeof(MSG_carton),PRIO_MSG_L))
											{
												perror ("[ConditionnementThread] Echec envoi FIN_APPLI a Impression ");
											}
											// Fermeture Boite aux lettres 
											mq_close (erreur_conditionnement);
											mq_close (conditionnement_dimension); 
											mq_close (conditionnement_erreur);
											mq_close (conditionnement_archivage);
											mq_close (conditionnement_impression);
											mq_close (lecture_conditionnement);
											// Le Thread Conditionnement se suicide
											pthread_exit(0); 	 					 
										}
										
									}
									if (msg_dimension.etat_piece == DIMENSION_OK)
									{
									
										nb_piece_cartonA++;
										printf("-----> NUMERO PIECE CARTON A : %d\n",nb_piece_cartonA);
									}
									else{
										if (msg_dimension.etat_piece == DIMENSION_NOK)
										{
											nb_piece_defectueuseA++;
											
										}
									}								
									
									if (nb_piece_defectueuseA == seuil_piece_defectueuse)
									{
										printf("[ConditionnementThread] Seuil Piece defectueuse Atteint Produit A\n"); 
										// Creation du message a envoyer 
										msg_versErreur.source = T_CONDITIONNEMENT; 
										msg_versErreur.message = PIECE_DEF; 
										msg_versErreur.heure = time(NULL);
										msg_versErreur.numLot = numero_lot; 
										msg_versErreur.cartonEnCours = numero_cartonA;
								
										if(0 != mq_send (conditionnement_erreur,(char*)&msg_versErreur,sizeof(MSG_versErreur),PRIO_MSG_L))
										{
											perror("[ConditionnementThread] Echec envoi message a Erreur "); 
										}
										// Attente du compte rendu Erreur 
										bytes_read = mq_receive(erreur_conditionnement,(char*)&msg_retErreur,sizeof(MSG_retErreur),NULL);
										if (bytes_read == -1)
										{
											perror("[ConditionnementThread] Echec lors de la reception: ");
										}
										if (msg_retErreur.reponse == FIN_APPLI)
										{
											msg_carton.type = FIN_APPLI;
											msg_carton.numCarton = ZERO;  
											msg_carton.numLot = ZERO;
											msg_carton.typeProduit = ZERO;
											//Envoi FIN APPLICATION a Impression
											if(0 != mq_send (conditionnement_impression,(char*)&msg_carton,sizeof(MSG_carton),PRIO_MSG_L))
											{
												perror("[ConditionnementThread] Echec envoi message a Impression ");
											}
											if(0 != mq_send (conditionnement_impression,(char*)&msg_carton,sizeof(MSG_carton),PRIO_MSG_L))
											{
												perror("[ConditionnementThread] Echec envoi message a Impression ");
											}

											// Close Boite aux lettres 
											mq_close (erreur_conditionnement);
											mq_close (conditionnement_dimension); 
											mq_close (conditionnement_erreur);
											mq_close (conditionnement_archivage);
											mq_close (conditionnement_impression);
											mq_close(lecture_conditionnement);
								
											pthread_exit(0); 
										}
										else{
											if(msg_retErreur.reponse == REPRISE)
											nb_piece_defectueuseA = 0;
										}	
									}				 	
				
									if (nb_piece_cartonA == taille_CartonA)
									{ 
										// Creation du message pour Impression 
										msg_carton.type = CARTON;
										msg_carton.numCarton = numero_cartonA;  
										msg_carton.numLot = numero_lot;
										msg_carton.typeProduit = PRODUIT_A;
										mq_send (conditionnement_impression,(char*)&msg_carton,sizeof(MSG_carton),PRIO_MSG_L);
										mq_send (conditionnement_impression,(char*)&msg_carton,sizeof(MSG_carton),PRIO_MSG_L);
										printf("[ConditionnementThread] CARTON %d ENVOYE A IMPRESSION\n",numero_cartonA); 
										// Creation du message pour Archivage 
										msg_versArchivage.source = T_CONDITIONNEMENT;
										msg_versArchivage.message = CARTON_PLEIN;
										msg_versArchivage.heure = time(NULL);
										msg_versArchivage.numLot = numero_lot;
										msg_versArchivage.cartonEnCours = numero_cartonA;
										msg_versArchivage.type = ARCHIVAGE;
										mq_send (conditionnement_archivage,(char*)&msg_versArchivage,sizeof(MSG_versArchivage),PRIO_MSG_L);	
										
									}
								}
								while (nb_piece_cartonA < taille_CartonA);
								// Fin Remplissage Carton A 
							}
							else
							{
								// Creation du message a envoyer a ERREUR  
								msg_versErreur.source = T_CONDITIONNEMENT; 
								msg_versErreur.message = PAS_DE_CARTON; 
								msg_versErreur.heure = time(NULL);
								msg_versErreur.numLot = numero_lot; 
								msg_versErreur.cartonEnCours = ZERO;
							
								// Envoi Message a Erreur
								if(0 != mq_send (conditionnement_erreur,(char*)&msg_versErreur,sizeof(MSG_versErreur),PRIO_MSG_L))
								{
									perror("[ConditionnementThread] Echec envoi message a Erreur "); 
								}

								// Attente du compte rendu Erreur 
								bytes_read = mq_receive(erreur_conditionnement,(char*)&msg_retErreur,sizeof(MSG_retErreur),NULL);	
								
								if (bytes_read == -1)
								{
									perror("[ConditionnementThread] Echec lors de la reception ");
								}
								if (msg_retErreur.reponse == FIN_APPLI)
								{
									
									msg_carton.type = FIN_APPLI;
									msg_carton.numCarton = ZERO;  
									msg_carton.numLot = ZERO;
									msg_carton.typeProduit = ZERO;
									// Envoi Message a Impression 
									if(0 != mq_send(conditionnement_impression,(char*)&msg_carton,sizeof(MSG_carton),PRIO_MSG_L))
									{
										perror("[ConditionnementThread] Echec envoi FIN APPLI a Impression ");
									}
									if(0 != mq_send(conditionnement_impression,(char*)&msg_carton,sizeof(MSG_carton),PRIO_MSG_L))
									{
										perror("[ConditionnementThread] Echec envoi FIN APPLI a Impression ");
									}

									// Close Boite aux lettres 
									mq_close (erreur_conditionnement);
									mq_close (conditionnement_dimension); 
									mq_close (conditionnement_erreur);
									mq_close (conditionnement_archivage);
									mq_close (conditionnement_impression);
									mq_close (lecture_conditionnement);
									pthread_exit(0); 
								}
							}
						}
						while(nb_cartonsA_sur_palette < taille_PaletteA);
						// Fin Remplissage Palette A 
					}while(nb_des_paletteA < nb_PaletteA);
					// Fin Remplissage de toutes les Palettes A 	
				}
					
				//-----------------DEBUT PRODUIT B
				printf("--------------PRODUIT B----------------\n"); 				
				if ( (taille_CartonB*taille_PaletteB*nb_PaletteB) != 0)
				{
					// Remplissage de toutes les palettes B	
					do{
						nb_des_paletteB++; 					
						printf("---> NUMERO PALETTE B : %d \n",nb_des_paletteB); 					
						nb_cartonsB_sur_palette = 0; 
						// Remplissage d une palette B
						do
						{
							
							// Seuil de piece defectueuse fixe
							seuil_piece_defectueuse = taille_CartonB/2; 

							presence_carton = PresenceCarton();
							if (presence_carton == CARTON_OK)
							{
								nb_cartonsB_sur_palette++; 
								numero_cartonB++;
								printf("---> NUMERO CARTON B : %d\n",numero_cartonB);

								nb_piece_cartonB = 0;
								nb_piece_defectueuseB = 0;
								// Remplissage d une carton B						
								do
								{
									struct timespec abs_timeout;
									abs_timeout.tv_sec = time(NULL) + 10;
									abs_timeout.tv_nsec = 0;  
									
									// Attente Message dimensionnement 
									bytes_read = mq_timedreceive(conditionnement_dimension,(char *)&msg_dimension,
							  sizeof(MSG_dimension),NULL,&abs_timeout);
									
									if (bytes_read == -1)
									{
										perror("[ConditionnementThread] Echec reception dimension piece \n ");
										// Creation Message pour Erreur
										msg_versErreur.source = T_CONDITIONNEMENT; 
										msg_versErreur.message = ABS_PIECE; 
										msg_versErreur.heure = time(NULL);
										msg_versErreur.numLot = numero_lot; 
										msg_versErreur.cartonEnCours = numero_cartonA;								
										if(0 != mq_send (conditionnement_erreur,(char*)&msg_versErreur,sizeof(MSG_versErreur),PRIO_MSG_L))
										{
											perror("[ConditionnementThread] Echec envoi message a Erreur "); 
										}	
										// Attente d un message de Erreur
										bytes_read = mq_receive(erreur_conditionnement,(char*)&msg_retErreur,sizeof(MSG_retErreur),NULL);
										if (bytes_read == -1)
										{
											perror("[ConditionnementThread] Echec lors de la reception ");
										}
										if (msg_retErreur.reponse == FIN_APPLI)
										{
											// Creation du message a envoyer a Impression
											msg_carton.type = FIN_APPLI;   
											msg_carton.numCarton = ZERO; 
											msg_carton.numLot = ZERO;
											msg_carton.typeProduit = ZERO;

											// Envoi de FIN APPLICATION a Impression 
											if (0 != mq_send (conditionnement_impression,(const char*)&msg_carton,sizeof(MSG_carton),PRIO_MSG_L))
											{
												perror ("[ConditionnementThread] Echec envoi FIN_APPLI a Impression ");
											}

											// Envoi de FIN APPLICATION a Impression 
											if (0 != mq_send (conditionnement_impression,(const char*)&msg_carton,sizeof(MSG_carton),PRIO_MSG_L))
											{
												perror ("[ConditionnementThread] Echec envoi FIN_APPLI a Impression ");
											}
											// Fermeture Boite aux lettres 
											mq_close (erreur_conditionnement);
											mq_close (conditionnement_dimension); 
											mq_close (conditionnement_erreur);
											mq_close (conditionnement_archivage);
											mq_close (conditionnement_impression);
											mq_close (lecture_conditionnement);
											// Le Thread Conditionnement se suicide
											pthread_exit(0); 
										}					 
									}
										
									
									if (msg_dimension.etat_piece == DIMENSION_OK)
									{
									
										nb_piece_cartonB++;
										printf("-----> NUMERO PIECE CARTON B : %d\n",nb_piece_cartonB);
									}else{
										if (msg_dimension.etat_piece == DIMENSION_NOK)
										{
											nb_piece_defectueuseB++;
											
										}
									}								
									
									if (nb_piece_defectueuseB == seuil_piece_defectueuse)
									{
										printf("[ConditionnementThread] Seuil Piece defectueuse Atteint Produit B\n"); 
										// Creation du message a envoyer 
										msg_versErreur.source = T_CONDITIONNEMENT; 
										msg_versErreur.message = PIECE_DEF; 
										msg_versErreur.heure = time(NULL);
										msg_versErreur.numLot = numero_lot; 
										msg_versErreur.cartonEnCours = numero_cartonB;
								
										if(0 != mq_send (conditionnement_erreur,(char*)&msg_versErreur,sizeof(MSG_versErreur),PRIO_MSG_L))
										{
											perror("[ConditionnementThread] Echec envoi message a Erreur "); 
										}
										// Attente du compte rendu Erreur 
										bytes_read = mq_receive(erreur_conditionnement,(char*)&msg_retErreur,sizeof(MSG_retErreur),NULL);
										if (bytes_read == -1)
										{
											perror("[ConditionnementThread] Echec lors de la reception: ");
										}
										if (msg_retErreur.reponse == FIN_APPLI)
										{
											msg_carton.type = FIN_APPLI;
											msg_carton.numCarton = ZERO;  
											msg_carton.numLot = ZERO;
											msg_carton.typeProduit = ZERO;
											//Envoi FIN APPLICATION a Impression
											if(0 != mq_send (conditionnement_impression,(char*)&msg_carton,sizeof(MSG_carton),PRIO_MSG_L))
											{
												perror("[ConditionnementThread] Echec envoi message a Impression ");
											}
											if(0 != mq_send (conditionnement_impression,(char*)&msg_carton,sizeof(MSG_carton),PRIO_MSG_L))
											{
												perror("[ConditionnementThread] Echec envoi message a Impression ");
											}

											// Close Boite aux lettres 
											mq_close (erreur_conditionnement);
											mq_close (conditionnement_dimension); 
											mq_close (conditionnement_erreur);
											mq_close (conditionnement_archivage);
											mq_close (conditionnement_impression);
											mq_close(lecture_conditionnement);
								
											pthread_exit(0); 
										}
										else{
											if(msg_retErreur.reponse == REPRISE)
											nb_piece_defectueuseB = 0;	
										}
									}				 	
									if (nb_piece_cartonB == taille_CartonB)
									{  
										// Creation du message pour Impression 
										msg_carton.type = CARTON;
										msg_carton.numCarton = numero_cartonB;  
										msg_carton.numLot = numero_lot;
										msg_carton.typeProduit = PRODUIT_B;
										mq_send (conditionnement_impression,(char*)&msg_carton,sizeof(MSG_carton),PRIO_MSG_L);
										mq_send (conditionnement_impression,(char*)&msg_carton,sizeof(MSG_carton),PRIO_MSG_L);
										printf("[ConditionnementThread] CARTON %d ENVOYE A IMPRESSION\n",numero_cartonB); 
										// Creation du message pour Archivage 
										msg_versArchivage.source = T_CONDITIONNEMENT;
										msg_versArchivage.message = CARTON_PLEIN;
										msg_versArchivage.heure = time(NULL);
										msg_versArchivage.numLot = numero_lot;
										msg_versArchivage.cartonEnCours = numero_cartonB;
										msg_versArchivage.type = ARCHIVAGE;
										mq_send (conditionnement_archivage,(char*)&msg_versArchivage,sizeof(MSG_versArchivage),PRIO_MSG_L);	
									
									}
								}
								while (nb_piece_cartonB < taille_CartonB); 
								// Fin Remplissage d un carton B 
							}
							else
							{
								// Creation du message a envoyer a ERREUR  
								msg_versErreur.source = T_CONDITIONNEMENT; 
								msg_versErreur.message = PAS_DE_CARTON; 
								msg_versErreur.heure = time(NULL);
								msg_versErreur.numLot = numero_lot; 
								msg_versErreur.cartonEnCours = ZERO;
							
								// Envoi Message a Erreur
								if(0 != mq_send (conditionnement_erreur,(char*)&msg_versErreur,sizeof(MSG_versErreur),PRIO_MSG_L))
								{
									perror("[ConditionnementThread] Echec envoi message a Erreur "); 
								}

								// Attente du compte rendu Erreur 
								bytes_read = mq_receive(erreur_conditionnement,(char*)&msg_retErreur,sizeof(MSG_retErreur),NULL);

								if (bytes_read == -1)
								{
									perror("[ConditionnementThread] Echec lors de la reception ");
								}
								if (msg_retErreur.reponse == FIN_APPLI)
								{
									msg_carton.type = FIN_APPLI;
									msg_carton.numCarton = ZERO;  
									msg_carton.numLot = ZERO;
									msg_carton.typeProduit = ZERO;
									// Envoi Message a Impression 
									if(0 != mq_send(conditionnement_impression,(char*)&msg_carton,sizeof(MSG_carton),PRIO_MSG_L))
									{
										perror("[ConditionnementThread] Echec envoi FIN APPLI a Impression ");
									}
									if(0 != mq_send(conditionnement_impression,(char*)&msg_carton,sizeof(MSG_carton),PRIO_MSG_L))
									{
										perror("[ConditionnementThread] Echec envoi FIN APPLI a Impression ");
									}

									// Close Boite aux lettres 
									mq_close (erreur_conditionnement);
									mq_close (conditionnement_dimension); 
									mq_close (conditionnement_erreur);
									mq_close (conditionnement_archivage);
									mq_close (conditionnement_impression);
									mq_close (lecture_conditionnement);
									pthread_exit(0); 
								}
							}
						}
						while(nb_cartonsB_sur_palette < taille_PaletteB);
						// Fin Remplissage d une Palette B 
					}while(nb_des_paletteB < nb_PaletteB);
					// Fin Remplissage de toutes les Palettes B 
				}
				// Fermeture du Clapet FIN Production
				FermetureClapet();
				// FIN DE LA PRODUCTION
				msg_carton.type = FIN_PROD;
				msg_carton.numCarton = ZERO;  
				msg_carton.numLot = ZERO;
				msg_carton.typeProduit = ZERO;
				// Envoi FIN PROD
				mq_send (conditionnement_impression,(char*)&msg_carton,sizeof(MSG_carton),PRIO_MSG_L);
				mq_send (conditionnement_impression,(char*)&msg_carton,sizeof(MSG_carton),PRIO_MSG_L);

				// Close Boite aux lettres 
				mq_close (erreur_conditionnement);
				mq_close (conditionnement_dimension); 
				mq_close (conditionnement_erreur);
				mq_close (conditionnement_archivage);
				mq_close (conditionnement_impression);
				mq_close (lecture_conditionnement);
				// Suicide pthread_exit 
				pthread_exit(0);
			}
		}
	}
	//----------Fin Phase Moteur

	//------------Phase de destruction
 	 
	//--------Fin Phase de destruction 
}
